{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 视频物体分割\n",
    "本案例分为以下几个章节：\n",
    "1. 视频物体分割简介\n",
    "2. OSVOS算法训练和预测\n",
    "3. 视频物体分割的应用\n",
    "\n",
    "下面我们开始本案例的学习，由于本案例的代码是在华为云ModelArts Notebook上运行，所以需要先按照如下步骤来进行Notebook环境的准备。\n",
    "\n",
    "### 进入ModelArts\n",
    "\n",
    "点击如下链接：https://www.huaweicloud.com/product/modelarts.html ， 进入ModelArts主页。点击“立即使用”按钮，输入用户名和密码登录，进入ModelArts使用页面。\n",
    "\n",
    "### 创建ModelArts Notebook\n",
    "\n",
    "下面，我们在ModelArts中创建一个Notebook开发环境，ModelArts Notebook提供网页版的Python开发环境，可以方便的编写、运行代码，并查看运行结果。\n",
    "\n",
    "第一步：在ModelArts服务主界面依次点击“开发环境”、“创建”\n",
    "\n",
    "![create_nb_create_button](./imgs/create_nb_create_button.png)\n",
    "\n",
    "第二步：填写notebook所需的参数：\n",
    "\n",
    "| 参数 | 说明 |\n",
    "| - - - - - | - - - - - |\n",
    "| 计费方式 | 按需计费  |\n",
    "| 名称 | 自定义名称 |\n",
    "| 工作环境 | Python3 |\n",
    "| 资源池 | 公共资源池 |\n",
    "| 类型 | GPU |\n",
    "| 规格 | [限时免费]体验规格GPU版 |\n",
    "| 存储配置 | EVS |\n",
    "| 磁盘规格 | 5GB |\n",
    "\n",
    "第三步：配置好Notebook参数后，点击下一步，进入Notebook信息预览。确认无误后，点击“立即创建”\n",
    "\n",
    "第四步：创建完成后，返回开发环境主界面，等待Notebook创建完毕后，打开Notebook，进行下一步操作。\n",
    "![modelarts_notebook_index](./imgs/modelarts_notebook_index.png)\n",
    "\n",
    "### 在ModelArts中创建开发环境\n",
    "\n",
    "接下来，我们创建一个实际的开发环境，用于后续的实验步骤。\n",
    "\n",
    "第一步：点击下图所示的“打开”按钮，进入刚刚创建的Notebook\n",
    "![enter_dev_env](imgs/enter_dev_env.png)\n",
    "\n",
    "第二步：创建一个Python3环境的的Notebook。点击右上角的\"New\"，然后创建Pytorch-1.0.0开发环境。\n",
    "\n",
    "第三步：点击左上方的文件名\"Untitled\"，并输入一个与本实验相关的名称，如\"object_segmentation\"\n",
    "![notebook_untitled_filename](./imgs/notebook_untitled_filename.png)\n",
    "![notebook_name_the_ipynb](./imgs/notebook_name_the_ipynb.png)\n",
    "\n",
    "\n",
    "### 在Notebook中编写并执行代码\n",
    "\n",
    "在Notebook中，我们输入一个简单的打印语句，然后点击上方的运行按钮，可以查看语句执行的结果：\n",
    "![run_helloworld](./imgs/run_helloworld.png)\n",
    "\n",
    "\n",
    "\n",
    "## 1. 视频物体分割简介\n",
    "视频物体分割就是从视频所有图像中将感兴趣物体的区域完整地分割出来。\n",
    "\n",
    "注意“感兴趣物体”这个词，“感兴趣物体”是指在一段视频中最容易捕获人眼注意力的一个或多个物体，比如下图中左上角子图中三个正在跳舞的人，这三个人物是“感兴趣物体”，而周围的人群不属于我们常识上的感兴趣物体，下图中的其他子图也是如此，因此视频物体分割算法一般不需要将视频图像中的所有物体都进行分割，而是只需要分割“感兴趣物体”即可。\n",
    "\n",
    "![vos.jpg](./imgs/vos.jpg)\n",
    "\n",
    "学术界在视频物体分割领域主要有三个研究方向：\n",
    "\n",
    "（1）半监督视频物体分割\n",
    "\n",
    "（2）交互式视频物体分割\n",
    "\n",
    "（3）无监督视频物体分割\n",
    "\n",
    "下面我们来一一讲解三个研究方向的内容。\n",
    "\n",
    "### 1.1 半监督视频物体分割\n",
    "\n",
    "半监督是指由用户给定感兴趣物体在视频第一帧图片上的人工标注真实分割区域，然后算法根据这一帧图片和标注进行学习，完成学习后，由算法来对后续所有帧图片进行分割区域的预测。\n",
    "\n",
    "![semi_learning](./imgs/semi_learning.jpg)\n",
    "\n",
    "如上图所示，第一行分别是一个视频的RGB图片，第二行是感兴趣物体区域，第一列是视频的第一帧图片和人工标注的分割区域，之后的三列分别是第20、40、60帧图片和算法预测的分割区域。\n",
    "\n",
    "半监督视频物体分割算法还可以再分为两类：有在线学习和无在线学习。有在线学习的算法就是上面提到的根据第一帧物体的 ground-truth，利用 one-shot learning 的策略来 fine-tune 分割模型，每次对一个视频进行预测前，都要先对该视频的第一帧进行学习，fine-tune一下模型，再进行预测，代表性算法是[One-Shot Video Object Segmentation](http://openaccess.thecvf.com/content_cvpr_2017/papers/Caelles_One-Shot_Video_Object_CVPR_2017_paper.pdf)。无在线学习的算法是指它的模型是事先训练好的，不需要针对样本进行 fine-tune，具有更好的时效性，代表性算法是[FEELVOS: Fast End-to-End Embedding Learning for Video Object Segmentation](https://arxiv.org/pdf/1902.09513)。\n",
    "\n",
    "### 1.2 交互式视频物体分割\n",
    "\n",
    "交互式视频物体分割是指算法在运行过程中需要人不断与其交互，然后根据人的交互信息来决定感兴趣物体并进行分割。\n",
    "\n",
    "![interactive_learning](./imgs/interactive_learning.jpg)\n",
    "\n",
    "如上图所示，是交互式视频物体分割算法的基本流程，第一帧根据人划的一条线或一个框来确定感兴趣物体，然后得到初始帧的物体分割结果，然后算法继续逐帧预测，直到上面的第3张图，算法分割区域发生了错误，选中了后面一只骆驼的部分区域作为分割区域，这时可以再结合一次人的交互，由人工进行划线区分正负样本，随后算法就进行修正，得到了第4张图的结果。这种交互式视频物体分割算法的特点就是通过人的多次交互达到较好的分割效果。代表性算法是[Fast User-Guided Video Object Segmentation by Interaction-and-propagation Networks](http://openaccess.thecvf.com/content_CVPR_2019/papers/Oh_Fast_User-Guided_Video_Object_Segmentation_by_Interaction-And-Propagation_Networks_CVPR_2019_paper.pdf)。\n",
    "\n",
    "### 1.3 无监督视频物体分割\n",
    "\n",
    "无监督视频物体分割是全自动的分割，除了 RGB 视频，没有其他任何输入，其目的是分割出视频中显著性的物体区域，是目前最新的一个研究方向。半监督和交互式视频物体分割中，感兴趣物体是事先指定的，不存在任何歧义，而在无监督视频物体分割中，物体显著性是主观概念，不同人之间存在一定的歧义，因此无监督视频物体分割算法可能需要输出视频中人眼会注意到的多个物体的分割结果。代表性算法是[UnOVOST: Unsupervised Offline Video Object Segmentation and Tracking for the 2019 Unsupervised DAVIS Challenge](https://davischallenge.org/challenge2019/papers/DAVIS-Unsupervised-Challenge-1st-Team.pdf).\n",
    "\n",
    "以上三个研究方向其实就是[DAVIS挑战赛](https://davischallenge.org/index.html)的三个任务，如果您对此感兴趣，可以前往其网站进行了解。\n",
    "\n",
    "在以上三个研究方向中，由于半监督视频物体分割算法的发展较为成熟，因此本案例采用该类算法的代表性算法OSVOS来实现一个视频物体分割的demo，接下来我们来开始执行OSVOS的代码。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. OSVOS算法训练和预测\n",
    "\n",
    "### 2.1 准备代码和数据\n",
    "相关代码、数据和模型都已准备好存放在OBS中，执行下面一段代码即可将其拷贝到Notebook中"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:root:Using MoXing-v1.15.1-92d9ed92\n",
      "INFO:root:Using OBS-Python-SDK-3.1.2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading datasets and code ...\n",
      "Download success\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import subprocess\n",
    "import moxing as mox\n",
    "\n",
    "print('Downloading datasets and code ...')\n",
    "if not os.path.exists('./video_object_segmention/OSVOS-PyTorch'):\n",
    "    mox.file.copy('s3://modelarts-labs-bj4/notebook/DL_video_object_segmentation/OSVOS-PyTorch.zip', \n",
    "                  './video_object_segmention/OSVOS-PyTorch.zip')\n",
    "    p1 = subprocess.run(['cd ./video_object_segmention/;unzip OSVOS-PyTorch.zip;rm OSVOS-PyTorch.zip'], \n",
    "                        stdout=subprocess.PIPE, shell=True, check=True)\n",
    "    if os.path.exists('./video_object_segmention/OSVOS-PyTorch'):\n",
    "        print('Download success')\n",
    "    else:\n",
    "        raise Exception('Download failed')\n",
    "else:\n",
    "    print('Download success')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 安装需要的python模块\n",
    "#### 本案例需要torch 0.4.0才能跑通，如果直接使用pip install torch==0.4.0，安装的是CUDA8.0编译的torch，但是ModelArts的默认CUDA版本为9.0，因此我们指定安装使用CUDA9.0编译的torch 0.4.0，该安装包已经存储在OBS，使用下面一行代码直接copy即可。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists('./video_object_segmention/torch-0.4.0-cp36-cp36m-linux_x86_64.whl'):\n",
    "    mox.file.copy('obs://modelarts-labs-bj4/notebook/DL_video_object_segmentation/torch-0.4.0-cp36-cp36m-linux_x86_64.whl',\n",
    "                 './video_object_segmention/torch-0.4.0-cp36-cp36m-linux_x86_64.whl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing ./video_object_segmention/torch-0.4.0-cp36-cp36m-linux_x86_64.whl\n",
      "Installing collected packages: torch\n",
      "  Found existing installation: torch 1.0.0\n",
      "    Uninstalling torch-1.0.0:\n",
      "      Successfully uninstalled torch-1.0.0\n",
      "Successfully installed torch-0.4.0\n",
      "\u001b[33mYou are using pip version 9.0.1, however version 20.1.1 is available.\n",
      "You should consider upgrading via the 'pip install --upgrade pip' command.\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!pip install ./video_object_segmention/torch-0.4.0-cp36-cp36m-linux_x86_64.whl  # 必须安装用CUDA9.0编译的torch 0.4.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting addict==2.2.1 (from -r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 1))\n",
      "  Downloading http://repo.myhuaweicloud.com/repository/pypi/packages/14/6f/beb258220417c1a0fe11e842f2e012a1be7eeeaa72a1d10ba17a804da367/addict-2.2.1-py3-none-any.whl\n",
      "Collecting cvbase==0.5.5 (from -r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 2))\n",
      "  Downloading http://repo.myhuaweicloud.com/repository/pypi/packages/74/08/551f262dd4535424b19723f686b84ac30b436d996191f90de42d739db64c/cvbase-0.5.5-py2.py3-none-any.whl (45kB)\n",
      "\u001b[K    100% |████████████████████████████████| 51kB 87.9MB/s ta 0:00:01\n",
      "\u001b[?25hCollecting mkl-fft==1.0.0.17 (from -r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 3))\n",
      "  Downloading http://repo.myhuaweicloud.com/repository/pypi/packages/08/39/829b09794352ccfff227d299e4e7afe56cc52fec66bb19814405594b2478/mkl_fft-1.0.0.17-cp36-cp36m-manylinux1_x86_64.whl (212kB)\n",
      "\u001b[K    100% |████████████████████████████████| 215kB 89.4MB/s ta 0:00:01\n",
      "\u001b[?25hCollecting mkl-random==1.0.1 (from -r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 4))\n",
      "  Downloading http://repo.myhuaweicloud.com/repository/pypi/packages/75/c0/7769ebbbcadf79613222a1e89d4278fb2d46bc98e554cd664a638a840747/mkl_random-1.0.1-cp36-cp36m-manylinux1_x86_64.whl (393kB)\n",
      "\u001b[K    100% |████████████████████████████████| 399kB 38.1MB/s ta 0:00:01\n",
      "\u001b[?25hCollecting mmcv==0.2.10 (from -r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 5))\n",
      "  Downloading http://repo.myhuaweicloud.com/repository/pypi/packages/f8/1e/399e97bb0e5a38675b90ed1f67a9496fb370e20a03b19850b7abb1246b81/mmcv-0.2.10.tar.gz (47kB)\n",
      "\u001b[K    100% |████████████████████████████████| 51kB 95.6MB/s ta 0:00:01\n",
      "\u001b[?25hCollecting terminaltables==3.1.0 (from -r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 6))\n",
      "  Downloading http://repo.myhuaweicloud.com/repository/pypi/packages/9b/c4/4a21174f32f8a7e1104798c445dacdc1d4df86f2f26722767034e4de4bff/terminaltables-3.1.0.tar.gz\n",
      "Requirement already satisfied: torchvision==0.2.1 in /home/ma-user/anaconda3/envs/Pytorch-1.0.0/lib/python3.6/site-packages (from -r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 7))\n",
      "Requirement already satisfied: numpy>=1.11.1 in /home/ma-user/anaconda3/envs/Pytorch-1.0.0/lib/python3.6/site-packages (from cvbase==0.5.5->-r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 2))\n",
      "Requirement already satisfied: pyyaml in /home/ma-user/anaconda3/envs/Pytorch-1.0.0/lib/python3.6/site-packages (from cvbase==0.5.5->-r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 2))\n",
      "Requirement already satisfied: six in /home/ma-user/anaconda3/envs/Pytorch-1.0.0/lib/python3.6/site-packages (from cvbase==0.5.5->-r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 2))\n",
      "Collecting intel-numpy (from mkl-fft==1.0.0.17->-r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 3))\n",
      "  Downloading http://repo.myhuaweicloud.com/repository/pypi/packages/ef/b3/fb79b1f34dc83822ea4e57c9a889ee32a34087139c12c9f1c3473f060d4d/intel_numpy-1.15.1-cp36-cp36m-manylinux1_x86_64.whl (6.1MB)\n",
      "\u001b[K    100% |████████████████████████████████| 6.1MB 122.0MB/s ta 0:00:01  | 4.3MB 104.3MB/s eta 0:00:01\n",
      "\u001b[?25hRequirement already satisfied: requests in /home/ma-user/anaconda3/envs/Pytorch-1.0.0/lib/python3.6/site-packages (from mmcv==0.2.10->-r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 5))\n",
      "Requirement already satisfied: opencv-python in /home/ma-user/anaconda3/envs/Pytorch-1.0.0/lib/python3.6/site-packages (from mmcv==0.2.10->-r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 5))\n",
      "Requirement already satisfied: Cython in /home/ma-user/anaconda3/envs/Pytorch-1.0.0/lib/python3.6/site-packages (from mmcv==0.2.10->-r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 5))\n",
      "Requirement already satisfied: torch in /home/ma-user/anaconda3/envs/Pytorch-1.0.0/lib/python3.6/site-packages (from torchvision==0.2.1->-r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 7))\n",
      "Requirement already satisfied: pillow>=4.1.1 in /home/ma-user/anaconda3/envs/Pytorch-1.0.0/lib/python3.6/site-packages (from torchvision==0.2.1->-r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 7))\n",
      "Collecting tbb4py (from intel-numpy->mkl-fft==1.0.0.17->-r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 3))\n",
      "  Downloading http://repo.myhuaweicloud.com/repository/pypi/packages/af/88/06532a4fb130ce4d1573a0b13ae3c58d689fe950e9806c507ba44d13ab17/tbb4py-2019.0-cp36-cp36m-manylinux1_x86_64.whl (225kB)\n",
      "\u001b[K    100% |████████████████████████████████| 235kB 25.4MB/s ta 0:00:01\n",
      "\u001b[?25hCollecting icc-rt (from intel-numpy->mkl-fft==1.0.0.17->-r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 3))\n",
      "  Downloading http://repo.myhuaweicloud.com/repository/pypi/packages/49/2d/3a308249f7e9d322a8858af3930670c8de7ebb131090a6e62473db844fdd/icc_rt-2020.0.133-py2.py3-none-manylinux1_x86_64.whl (11.2MB)\n",
      "\u001b[K    100% |████████████████████████████████| 11.2MB 83.6MB/s ta 0:00:011ta 0:00:01MB/s eta 0:00:01\n",
      "\u001b[?25hCollecting mkl (from intel-numpy->mkl-fft==1.0.0.17->-r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 3))\n",
      "  Downloading http://repo.myhuaweicloud.com/repository/pypi/packages/9b/98/c892b77b755cb0c53491eabc88c49451a92e36fa5c5baf578e77b91ee31d/mkl-2019.0-py2.py3-none-manylinux1_x86_64.whl (261.0MB)\n",
      "\u001b[K    100% |████████████████████████████████| 261.0MB 121.7MB/s ta 0:00:01030:00:03/s eta 0:00:03▍                             | 19.1MB 100.5MB/s eta 0:00:03 | 21.4MB 101.2MB/s eta 0:00:03                            | 26.4MB 102.0MB/s eta 0:00:03��██▋                            | 29.2MB 102.0MB/s eta 0:00:03████▏                           | 34.1MB 93.4MB/s eta 0:00:03      | 39.6MB 105.4MB/s eta 0:00:0318% |██████                          | 48.3MB 95.0MB/s eta 0:00:03█▋                         | 53.8MB 44.6MB/s eta 0:00:05��██████▊                        | 62.9MB 58.6MB/s eta 0:00:04    | 68.5MB 127.9MB/s eta 0:00:02  | 72.0MB 128.3MB/s eta 0:00:02�████████▌                      | 77.6MB 137.6MB/s eta 0:00:02��███████                      | 82.0MB 135.9MB/s eta 0:00:0242.6MB/s eta 0:00:02�█████████▏                    | 91.0MB 69.4MB/s eta 0:00:03 eta 0:00:033MB 53.9MB/s eta 0:00:043.3MB 61.7MB/s eta 0:00:03�█████████▏                  | 107.1MB 54.9MB/s eta 0:00:03��████▊                  | 111.6MB 137.1MB/s eta 0:00:02[K    44% |██████████████▏                 | 115.5MB 120.7MB/s eta 0:00:0203�███                 | 123.2MB 128.4MB/s eta 0:00:02       | 127.4MB 65.3MB/s eta 0:00:03       | 131.0MB 137.2MB/s eta 0:00:01��████████▋               | 135.2MB 119.6MB/s eta 0:00:02�███████████               | 139.2MB 146.7MB/s eta 0:00:012.9MB 139.1MB/s eta 0:00:018.5MB/s eta 0:00:01█████████████▌             | 150.9MB 60.3MB/s eta 0:00:02     | 155.3MB 48.7MB/s eta 0:00:03:00:02  63% |████████████████████▍           | 166.3MB 126.1MB/s eta 0:00:01    65% |████████████████████▉           | 170.2MB 123.8MB/s eta 0:00:01███▍          | 174.3MB 62.3MB/s eta 0:00:02178.1MB 119.2MB/s eta 0:00:01ta 0:00:01█████▉         | 186.6MB 95.7MB/s eta 0:00:01██████████████████▎        | 190.0MB 63.6MB/s eta 0:00:02�██████████████████▊        | 193.5MB 115.9MB/s eta 0:00:0111 134.2MB/s eta 0:00:01�██████████████▌      | 207.7MB 67.2MB/s eta 0:00:01██████████████████████████      | 211.7MB 141.6MB/s eta 0:00:01B/s eta 0:00:01�█████▊     | 218.1MB 145.0MB/s eta 0:00:015MB/s eta 0:00:01��█████    | 228.4MB 129.9MB/s eta 0:00:01:00:01��████████▏  | 238.0MB 49.2MB/s eta 0:00:0144.6MB 103.3MB/s eta 0:00:01�███████▍ | 247.7MB 56.0MB/s eta 0:00:01████████▉ | 251.3MB 111.2MB/s eta 0:00:01��██████████████████▎| 254.6MB 126.9MB/s eta 0:00:01�█████▊| 258.7MB 141.6MB/s eta 0:00:01\n",
      "\u001b[?25hRequirement already satisfied: chardet<3.1.0,>=3.0.2 in /home/ma-user/anaconda3/envs/Pytorch-1.0.0/lib/python3.6/site-packages (from requests->mmcv==0.2.10->-r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 5))\n",
      "Requirement already satisfied: idna<2.7,>=2.5 in /home/ma-user/anaconda3/envs/Pytorch-1.0.0/lib/python3.6/site-packages (from requests->mmcv==0.2.10->-r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 5))\n",
      "Requirement already satisfied: urllib3<1.23,>=1.21.1 in /home/ma-user/anaconda3/envs/Pytorch-1.0.0/lib/python3.6/site-packages (from requests->mmcv==0.2.10->-r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 5))\n",
      "Requirement already satisfied: certifi>=2017.4.17 in /home/ma-user/anaconda3/envs/Pytorch-1.0.0/lib/python3.6/site-packages (from requests->mmcv==0.2.10->-r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 5))\n",
      "Collecting tbb==2019.* (from tbb4py->intel-numpy->mkl-fft==1.0.0.17->-r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 3))\n",
      "  Downloading http://repo.myhuaweicloud.com/repository/pypi/packages/28/53/8bf93994fd985ea08c1ef64c7ec94a433611c6f6af5e3ddcc8c49d83fd5c/tbb-2019.0-py2.py3-none-manylinux1_x86_64.whl (895kB)\n",
      "\u001b[K    100% |████████████████████████████████| 901kB 71.6MB/s ta 0:00:01\n",
      "\u001b[?25hCollecting intel-openmp==2020.* (from icc-rt->intel-numpy->mkl-fft==1.0.0.17->-r ./video_object_segmention/OSVOS-PyTorch/requirements.txt (line 3))\n",
      "  Downloading http://repo.myhuaweicloud.com/repository/pypi/packages/fe/eb/85eac048aec9c45f0fdf6a9255ff18095827b465d216d49aa44f942589f4/intel_openmp-2020.0.133-py2.py3-none-manylinux1_x86_64.whl (919kB)\n",
      "\u001b[K    100% |████████████████████████████████| 921kB 64.3MB/s ta 0:00:01\n",
      "\u001b[?25hBuilding wheels for collected packages: mmcv, terminaltables\n",
      "  Running setup.py bdist_wheel for mmcv ... \u001b[?25ldone\n",
      "\u001b[?25h  Stored in directory: /home/ma-user/.cache/pip/wheels/d4/cc/c6/94e597186b441ce5a96e9ecd1c96aba314ac8b2630809b954a\n",
      "  Running setup.py bdist_wheel for terminaltables ... \u001b[?25ldone\n",
      "\u001b[?25h  Stored in directory: /home/ma-user/.cache/pip/wheels/b0/c5/2a/b5a0fd296778af556f930a6f233c6f0307313fdfe779ddb06f\n",
      "Successfully built mmcv terminaltables\n",
      "Installing collected packages: addict, terminaltables, cvbase, tbb, tbb4py, intel-openmp, icc-rt, mkl-random, mkl, intel-numpy, mkl-fft, mmcv\n",
      "Successfully installed addict-2.2.1 cvbase-0.5.5 icc-rt-2020.0.133 intel-numpy-1.15.1 intel-openmp-2020.0.133 mkl-2019.0 mkl-fft-1.0.0.17 mkl-random-1.0.1 mmcv-0.2.10 tbb-2019.0 tbb4py-2019.0 terminaltables-3.1.0\n",
      "\u001b[33mYou are using pip version 9.0.1, however version 20.1.1 is available.\n",
      "You should consider upgrading via the 'pip install --upgrade pip' command.\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!pip install -r ./video_object_segmention/OSVOS-PyTorch/requirements.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 注意！安装完以上模块后，会有一些c++库的更新，因此需要点击本页面顶部菜单栏的 Kernel，再点 Restart"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "导入需要的python模块"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import division\n",
    "\n",
    "import os\n",
    "import cv2\n",
    "import sys\n",
    "sys.path.insert(0, './video_object_segmention/OSVOS-PyTorch')\n",
    "import socket\n",
    "import time\n",
    "import timeit\n",
    "import numpy as np\n",
    "from datetime import datetime\n",
    "# from tensorboardX import SummaryWriter\n",
    "\n",
    "# PyTorch includes\n",
    "import torch\n",
    "import torch.optim as optim\n",
    "from torchvision import transforms\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "# Custom includes\n",
    "from dataloaders import davis_2016 as db\n",
    "from dataloaders import custom_transforms as tr\n",
    "from util import visualize as viz\n",
    "import scipy.misc as sm\n",
    "import networks.vgg_osvos as vo\n",
    "from layers.osvos_layers import class_balanced_cross_entropy_loss\n",
    "from dataloaders.helpers import *\n",
    "from mypath import Path\n",
    "from IPython.display import clear_output, Image, display"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义模型和训练超参"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Constructing OSVOS architecture..\n",
      "Initializing weights..\n",
      "Initializing weights success\n"
     ]
    }
   ],
   "source": [
    "# Setting of parameters\n",
    "if 'SEQ_NAME' not in os.environ.keys():\n",
    "    seq_name = 'flamingo'\n",
    "else:\n",
    "    seq_name = str(os.environ['SEQ_NAME'])\n",
    "\n",
    "db_root_dir = Path.db_root_dir()  # 训练数据所在路径，定义在./video_object_segmention/OSVOS-PyTorch/mypath.py中\n",
    "save_dir = Path.save_root_dir()   # 训练结果保存路径，定义在./video_object_segmention/OSVOS-PyTorch/mypath.py中\n",
    "\n",
    "if not os.path.exists(save_dir):\n",
    "    os.makedirs(os.path.join(save_dir))\n",
    "\n",
    "vis_net = 0  # Visualize the network?\n",
    "vis_res = 0  # Visualize the results?\n",
    "nAveGrad = 5  # Average the gradient every nAveGrad iterations\n",
    "nEpochs = 200 * nAveGrad  # Number of epochs for training  # 总的训练轮数\n",
    "snapshot = nEpochs  # Store a model every snapshot epochs\n",
    "parentEpoch = 240\n",
    "\n",
    "# Parameters in p are used for the name of the model\n",
    "p = {\n",
    "    'trainBatch': 1,  # Number of Images in each mini-batch\n",
    "    }\n",
    "seed = 0\n",
    "\n",
    "parentModelName = 'parent'\n",
    "# Select which GPU, -1 if CPU\n",
    "gpu_id = 0\n",
    "device = torch.device(\"cuda:\"+str(gpu_id) if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# Network definition\n",
    "net = vo.OSVOS(pretrained=0)\n",
    "net.load_state_dict(torch.load(os.path.join(save_dir, parentModelName+'_epoch-'+str(parentEpoch-1)+'.pth'),\n",
    "                               map_location=lambda storage, loc: storage))\n",
    "print('Initializing weights success')\n",
    "\n",
    "# Logging into Tensorboard\n",
    "log_dir = os.path.join(save_dir, 'runs', datetime.now().strftime('%b%d_%H-%M-%S') + '_' + socket.gethostname()+'-'+seq_name)\n",
    "# writer = SummaryWriter(log_dir=log_dir)\n",
    "\n",
    "net.to(device)  # PyTorch 0.4.0 style\n",
    "\n",
    "# Use the following optimizer\n",
    "lr = 1e-8\n",
    "wd = 0.0002\n",
    "optimizer = optim.SGD([\n",
    "    {'params': [pr[1] for pr in net.stages.named_parameters() if 'weight' in pr[0]], 'weight_decay': wd},\n",
    "    {'params': [pr[1] for pr in net.stages.named_parameters() if 'bias' in pr[0]], 'lr': lr * 2},\n",
    "    {'params': [pr[1] for pr in net.side_prep.named_parameters() if 'weight' in pr[0]], 'weight_decay': wd},\n",
    "    {'params': [pr[1] for pr in net.side_prep.named_parameters() if 'bias' in pr[0]], 'lr': lr*2},\n",
    "    {'params': [pr[1] for pr in net.upscale.named_parameters() if 'weight' in pr[0]], 'lr': 0},\n",
    "    {'params': [pr[1] for pr in net.upscale_.named_parameters() if 'weight' in pr[0]], 'lr': 0},\n",
    "    {'params': net.fuse.weight, 'lr': lr/100, 'weight_decay': wd},\n",
    "    {'params': net.fuse.bias, 'lr': 2*lr/100},\n",
    "    ], lr=lr, momentum=0.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义数据生成器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done initializing train_seqs Dataset\n",
      "Done initializing val_seqs Dataset\n"
     ]
    }
   ],
   "source": [
    "# Preparation of the data loaders\n",
    "# Define augmentation transformations as a composition\n",
    "composed_transforms = transforms.Compose([tr.RandomHorizontalFlip(),\n",
    "                                          tr.ScaleNRotate(rots=(-30, 30), scales=(.75, 1.25)),\n",
    "                                          tr.ToTensor()])\n",
    "# Training dataset and its iterator\n",
    "db_train = db.DAVIS2016(train=True, db_root_dir=db_root_dir, transform=composed_transforms, seq_name=seq_name)\n",
    "trainloader = DataLoader(db_train, batch_size=p['trainBatch'], shuffle=True, num_workers=1)\n",
    "\n",
    "# Testing dataset and its iterator\n",
    "db_test = db.DAVIS2016(train=False, db_root_dir=db_root_dir, transform=tr.ToTensor(), seq_name=seq_name)\n",
    "testloader = DataLoader(db_test, batch_size=1, shuffle=False, num_workers=1)\n",
    "\n",
    "\n",
    "num_img_tr = len(trainloader)\n",
    "num_img_ts = len(testloader)\n",
    "loss_tr = []\n",
    "aveGrad = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 开始在线学习\n",
    "默认训练1000epoch，总耗时约5分钟"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start of Online Training, sequence: flamingo\n",
      "[Epoch: 50, numImages:     1]\n",
      "Loss: 304.267090\n",
      "[Epoch: 100, numImages:     1]\n",
      "Loss: 361.602173\n",
      "[Epoch: 150, numImages:     1]\n",
      "Loss: 342.072937\n",
      "[Epoch: 200, numImages:     1]\n",
      "Loss: 347.585236\n",
      "[Epoch: 250, numImages:     1]\n",
      "Loss: 945.120056\n",
      "[Epoch: 300, numImages:     1]\n",
      "Loss: 416.114227\n",
      "[Epoch: 350, numImages:     1]\n",
      "Loss: 314.653259\n",
      "[Epoch: 400, numImages:     1]\n",
      "Loss: 526.422791\n",
      "[Epoch: 450, numImages:     1]\n",
      "Loss: 308.013214\n",
      "[Epoch: 500, numImages:     1]\n",
      "Loss: 262.596466\n",
      "[Epoch: 550, numImages:     1]\n",
      "Loss: 405.808197\n",
      "[Epoch: 600, numImages:     1]\n",
      "Loss: 458.469360\n",
      "[Epoch: 650, numImages:     1]\n",
      "Loss: 568.991455\n",
      "[Epoch: 700, numImages:     1]\n",
      "Loss: 316.690491\n",
      "[Epoch: 750, numImages:     1]\n",
      "Loss: 557.274231\n",
      "[Epoch: 800, numImages:     1]\n",
      "Loss: 596.683594\n",
      "[Epoch: 850, numImages:     1]\n",
      "Loss: 244.148804\n",
      "[Epoch: 900, numImages:     1]\n",
      "Loss: 275.538696\n",
      "[Epoch: 950, numImages:     1]\n",
      "Loss: 588.870972\n",
      "[Epoch: 1000, numImages:     1]\n",
      "Loss: 524.308960\n",
      "Online training success, model saved at ./video_object_segmention/OSVOS-PyTorch/./models/flamingo_epoch-999.pth\n",
      "Online training time: 220.86139497393742\n"
     ]
    }
   ],
   "source": [
    "print(\"Start of Online Training, sequence: \" + seq_name)\n",
    "start_time = timeit.default_timer()\n",
    "# Main Training and Testing Loop\n",
    "for epoch in range(0, nEpochs):\n",
    "    # One training epoch\n",
    "    running_loss_tr = 0\n",
    "    np.random.seed(seed + epoch)\n",
    "    for ii, sample_batched in enumerate(trainloader):\n",
    "\n",
    "        inputs, gts = sample_batched['image'], sample_batched['gt']\n",
    "\n",
    "        # Forward-Backward of the mini-batch\n",
    "        inputs.requires_grad_()\n",
    "        inputs, gts = inputs.to(device), gts.to(device)\n",
    "\n",
    "        outputs = net.forward(inputs)\n",
    "\n",
    "        # Compute the fuse loss\n",
    "        loss = class_balanced_cross_entropy_loss(outputs[-1], gts, size_average=False)\n",
    "        running_loss_tr += loss.item()  # PyTorch 0.4.0 style\n",
    "\n",
    "        # Print stuff\n",
    "        if epoch % (nEpochs//20) == (nEpochs//20 - 1):\n",
    "            running_loss_tr /= num_img_tr\n",
    "            loss_tr.append(running_loss_tr)\n",
    "\n",
    "            print('[Epoch: %d, numImages: %5d]' % (epoch+1, ii + 1))\n",
    "            print('Loss: %f' % running_loss_tr)\n",
    "            # writer.add_scalar('data/total_loss_epoch', running_loss_tr, epoch)\n",
    "\n",
    "        # Backward the averaged gradient\n",
    "        loss /= nAveGrad\n",
    "        loss.backward()\n",
    "        aveGrad += 1\n",
    "\n",
    "        # Update the weights once in nAveGrad forward passes\n",
    "        if aveGrad % nAveGrad == 0:\n",
    "            # writer.add_scalar('data/total_loss_iter', loss.item(), ii + num_img_tr * epoch)\n",
    "            optimizer.step()\n",
    "            optimizer.zero_grad()\n",
    "            aveGrad = 0\n",
    "\n",
    "    # Save the model\n",
    "    if (epoch % snapshot) == snapshot - 1 and epoch != 0:\n",
    "        torch.save(net.state_dict(), os.path.join(save_dir, seq_name + '_epoch-'+str(epoch) + '.pth'))\n",
    "\n",
    "stop_time = timeit.default_timer()\n",
    "print('Online training success, model saved at', os.path.join(save_dir, seq_name + '_epoch-'+str(epoch) + '.pth'))\n",
    "print('Online training time: ' + str(stop_time - start_time))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4 测试模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing Network\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma-user/anaconda3/envs/Pytorch-1.0.0/lib/python3.6/site-packages/ipykernel_launcher.py:29: DeprecationWarning: `imsave` is deprecated!\n",
      "`imsave` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.\n",
      "Use ``imageio.imwrite`` instead.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test end\n",
      "Results saved at ./video_object_segmention/OSVOS-PyTorch/./models/Results/flamingo\n"
     ]
    }
   ],
   "source": [
    "# Testing Phase\n",
    "if vis_res:\n",
    "    import matplotlib.pyplot as plt\n",
    "    plt.close(\"all\")\n",
    "    plt.ion()\n",
    "    f, ax_arr = plt.subplots(1, 3)\n",
    "\n",
    "save_dir_res = os.path.join(save_dir, 'Results', seq_name)  # 图片测试结果保存路径\n",
    "if not os.path.exists(save_dir_res):\n",
    "    os.makedirs(save_dir_res)\n",
    "\n",
    "print('Testing Network')\n",
    "with torch.no_grad():  # PyTorch 0.4.0 style\n",
    "    # Main Testing Loop\n",
    "    for ii, sample_batched in enumerate(testloader):\n",
    "        img, gt, fname = sample_batched['image'], sample_batched['gt'], sample_batched['fname']\n",
    "\n",
    "        # Forward of the mini-batch\n",
    "        inputs, gts = img.to(device), gt.to(device)\n",
    "\n",
    "        outputs = net.forward(inputs)\n",
    "\n",
    "        for jj in range(int(inputs.size()[0])):\n",
    "            pred = np.transpose(outputs[-1].cpu().data.numpy()[jj, :, :, :], (1, 2, 0))\n",
    "            pred = 1 / (1 + np.exp(-pred))\n",
    "            pred = np.squeeze(pred)\n",
    "\n",
    "            # Save the result, attention to the index jj\n",
    "            sm.imsave(os.path.join(save_dir_res, os.path.basename(fname[jj]) + '.png'), pred)\n",
    "\n",
    "            if vis_res:\n",
    "                img_ = np.transpose(img.numpy()[jj, :, :, :], (1, 2, 0))\n",
    "                gt_ = np.transpose(gt.numpy()[jj, :, :, :], (1, 2, 0))\n",
    "                gt_ = np.squeeze(gt)\n",
    "                # Plot the particular example\n",
    "                ax_arr[0].cla()\n",
    "                ax_arr[1].cla()\n",
    "                ax_arr[2].cla()\n",
    "                ax_arr[0].set_title('Input Image')\n",
    "                ax_arr[1].set_title('Ground Truth')\n",
    "                ax_arr[2].set_title('Detection')\n",
    "                ax_arr[0].imshow(im_normalize(img_))\n",
    "                ax_arr[1].imshow(gt_)\n",
    "                ax_arr[2].imshow(im_normalize(pred))\n",
    "                plt.pause(0.001)\n",
    "# writer.close()\n",
    "print('Test end')\n",
    "print('Results saved at', save_dir_res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5 查看视频分割结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "end\n"
     ]
    }
   ],
   "source": [
    "src_dir = './video_object_segmention/OSVOS-PyTorch/DAVIS_2016/JPEGImages/480p/flamingo'\n",
    "result_dir = './video_object_segmention/OSVOS-PyTorch/./models/Results/flamingo'\n",
    "files = os.listdir(result_dir)\n",
    "files.sort()\n",
    "for file_name in files:\n",
    "    clear_output(wait=True)\n",
    "    src_img = cv2.imread(os.path.join(src_dir, file_name.split('.')[0] + '.jpg'))\n",
    "    result_img = cv2.imread(os.path.join(result_dir, file_name))\n",
    "    src_img = cv2.resize(src_img, (416, 256), interpolation=cv2.INTER_AREA)\n",
    "    result_img = cv2.resize(result_img, (416, 256), interpolation=cv2.INTER_AREA)\n",
    "    cv2.putText(src_img, 'id: ' + str(file_name.split('.')[0]), (15, 15), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)  # 画frame_id\n",
    "    cv2.putText(result_img, 'id: ' + str(file_name.split('.')[0]), (15, 15), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)  # 画frame_id\n",
    "    img_show = np.hstack((src_img, np.zeros((256, 20, 3), dtype=src_img.dtype), result_img))\n",
    "    display(Image(data=cv2.imencode('.jpg', img_show)[1]))\n",
    "    time.sleep(0.04)\n",
    "print('end')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以从上面的分割结果看出，目标大概是能被分割的，但是细节部分还存在一些差异，特别是目标之外的区域也被分割了"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 视频物体分割的应用\n",
    "如果你已经得到了一个视频的物体分割结果，那么可以用来做什么呢？\n",
    "\n",
    "视频物体分割是一项广泛使用的技术，电影电视特效、短视频直播等可以用该技术将场景中的前景从背景中分离出来，通过修改或替换背景，可以将任务设置在现实不存在或不易实现的场景、强化信息的冲击力。传统方式可通过视频图像的手工逐帧抠图方式（比如，摄影在带绿幕的专业摄影棚环境摄制，后期特效完成背景移除切换，如下图所示），比如《复仇者联盟》《美国队长》《钢铁侠》等通过专业影视处理软件加入各种逼真的特效，让影片更加有趣，更加震撼。\n",
    "\n",
    "![koutu.jpg](./imgs/koutu.jpg)\n",
    "\n",
    "再比如华为Mate 20系列手机新增的人像留色功能，能够在录像过程中，实时识别出人物的轮廓，然后通过AI优化只保留人物衣服、皮肤、头发的颜色，将周边景物全部黑白化，如此一来使人物主体更加突出，打造大片既视感。这种人像留色功能就是使用了视频物体分割的技术，将人物从视频中分割出来，再保留其色彩。\n",
    "\n",
    "![renxiangliuse.jpg](./imgs/renxiangliuse.jpg)\n",
    "![renxiangliuse_2.jpg](./imgs/renxiangliuse_2.jpg)\n",
    "\n",
    "接下来，我们将实现视频抠图的另一种应用：将某个目标从视频中去掉，仿佛该目标从来没在视频中出现过一样。本案例采用的视频抠图算法是[Deep Flow-Guided Video Inpainting](https://arxiv.org/pdf/1905.02884.pdf)\n",
    "\n",
    "### 3.1 准备代码和数据\n",
    "相关代码、数据和模型都已准备好存放在OBS中，执行下面一段代码即可将其拷贝到Notebook中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:root:Using MoXing-v1.15.1-92d9ed92\n",
      "INFO:root:Using OBS-Python-SDK-3.1.2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading datasets and code ...\n",
      "Download success\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import subprocess\n",
    "import moxing as mox\n",
    "\n",
    "print('Downloading datasets and code ...')\n",
    "if not os.path.exists('./video_object_segmention/Deep-Flow-Guided-Video-Inpainting'):\n",
    "    mox.file.copy('s3://modelarts-labs-bj4/notebook/DL_video_object_segmentation/Deep-Flow-Guided-Video-Inpainting.zip', \n",
    "                  './video_object_segmention/Deep-Flow-Guided-Video-Inpainting.zip')\n",
    "    p1 = subprocess.run(['cd ./video_object_segmention/;unzip Deep-Flow-Guided-Video-Inpainting.zip;rm Deep-Flow-Guided-Video-Inpainting.zip'], \n",
    "                        stdout=subprocess.PIPE, shell=True, check=True)\n",
    "    if os.path.exists('./video_object_segmention/Deep-Flow-Guided-Video-Inpainting'):\n",
    "        print('Download success')\n",
    "    else:\n",
    "        raise Exception('Download failed')\n",
    "else:\n",
    "    print('Download success')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 运行算法demo\n",
    "回到 ModelArts Notebook 页面，按照下图打开一个terminal：\n",
    "![open_terminal.jpg](./imgs/open_terminal.jpg)\n",
    "然后复制以下四条命令到terminal中粘贴执行，执行过程耗时约2分半：\n",
    "```shell\n",
    "\n",
    "source activate /home/ma-user/anaconda3/envs/Pytorch-1.0.0\n",
    "\n",
    "cd `find ~/work/ -name \"Deep-Flow-Guided-Video-Inpainting\"`\n",
    "\n",
    "bash install_scripts.sh\n",
    "\n",
    "python tools/video_inpaint.py --frame_dir ../OSVOS-PyTorch/DAVIS_2016/JPEGImages/480p/flamingo --MASK_ROOT ../OSVOS-PyTorch/DAVIS_2016/Annotations/480p/flamingo --img_size 512 832 --FlowNet2 --DFC --ResNet101 --Propagation --enlarge_mask\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 查看视频抠图结果\n",
    "执行下面这段代码将看到视频抠图的结果，左侧视频是原视频，右侧视频是去除了一只火烈鸟目标之后的视频，可以看到目标抠除的效果是非常好的，完全不影响背景，仿佛这个目标在视频中就从来没有出现过一样。\n",
    "\n",
    "注意：由于视频物体分割算法的发展时间较短，离实用场景还有一段距离，所以本案例的视频抠图demo使用的目标分割区域是人工标注的（存储位置在./video_object_segmention/Deep-Flow-Guided-Video-Inpainting/demo/masks），而不是上面的OSVOS算法输出的分割区域。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "end\n"
     ]
    }
   ],
   "source": [
    "src_dir = './video_object_segmention/OSVOS-PyTorch/DAVIS_2016/JPEGImages/480p/flamingo'\n",
    "result_dir = './video_object_segmention/OSVOS-PyTorch/DAVIS_2016/JPEGImages/480p/Inpaint_Res/inpaint_res'\n",
    "files = os.listdir(result_dir)\n",
    "files.sort()\n",
    "for file_name in files:\n",
    "    clear_output(wait=True)\n",
    "    src_img = cv2.imread(os.path.join(src_dir, file_name.split('.')[0] + '.jpg'))\n",
    "    result_img = cv2.imread(os.path.join(result_dir, file_name))\n",
    "    src_img = cv2.resize(src_img, (416, 256), interpolation=cv2.INTER_AREA)\n",
    "    result_img = cv2.resize(result_img, (416, 256), interpolation=cv2.INTER_AREA)\n",
    "    cv2.putText(src_img, 'id: ' + str(file_name.split('.')[0]), (15, 15), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)  # 画frame_id\n",
    "    cv2.putText(result_img, 'id: ' + str(file_name.split('.')[0]), (15, 15), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)  # 画frame_id\n",
    "    img_show = np.hstack((src_img, np.zeros((256, 20, 3), dtype=src_img.dtype), result_img))\n",
    "    display(Image(data=cv2.imencode('.jpg', img_show)[1]))\n",
    "    time.sleep(0.02)\n",
    "print('end')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "参考资料\n",
    "\n",
    "[视频分割在移动端的算法进展综述](https://zhuanlan.zhihu.com/p/60621619)\n",
    "\n",
    "[视频物体分割算法的三个方向与最新应用](https://new.qq.com/omn/20190731/20190731A0BMCE00.html)\n",
    "\n",
    "[https://davischallenge.org/index.html](https://davischallenge.org/index.html)\n",
    "\n",
    "[https://github.com/kmaninis/OSVOS-PyTorch](https://github.com/kmaninis/OSVOS-PyTorch)\n",
    "\n",
    "[https://github.com/nbei/Deep-Flow-Guided-Video-Inpainting](https://github.com/nbei/Deep-Flow-Guided-Video-Inpainting)\n",
    "\n",
    "[A Benchmark Dataset and Evaluation Methodology for Video Object Segmentation](https://www.cv-foundation.org/openaccess/content_cvpr_2016/papers/Perazzi_A_Benchmark_Dataset_CVPR_2016_paper.pdf)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Pytorch-1.0.0",
   "language": "python",
   "name": "pytorch-1.0.0"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
